package cn.itcast.service.system.impl;

import cn.itcast.dao.system.ModuleDao;
import cn.itcast.dao.system.UserDao;
import cn.itcast.domain.system.Module;
import cn.itcast.domain.system.User;
import cn.itcast.service.system.ModuleService;
import cn.itcast.service.system.cn.itcast.util.JedisUtils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.UUID;

@Service
public class ModuleServiceImpl implements ModuleService {

    @Autowired
    private ModuleDao moduleDao;
    @Autowired
    private UserDao userDao;

    @Override
    public PageInfo<Module> findByPage(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<Module> list = moduleDao.findAll();
        return new PageInfo<>(list);
    }

    @Override
    public List<Module> findAll() throws Exception {
        List<Module> moduleList = null;
        ObjectMapper objectMapper = new ObjectMapper();
        //1.查询redis里面存储的类别列表数据返回json字符串数据
        //获取Jedis连接对象
        Jedis jedis = JedisUtils.getJedis();
        //读取缓存数据
        String jsonData = jedis.get("moduleList");

        //2.判断字符串是否有数据
        if (jsonData==null){
            //3.如果json字符串数据无效，调用数据库获取，并写入缓存
            //调用dao获取类别列表数据
            moduleList = moduleDao.findAll();
            System.out.println("=============去数据库查数据了=============================");
            //写入缓存
            jsonData = objectMapper.writeValueAsString(moduleList);
            jedis.set("moduleList",jsonData);
        }else{
            //4.如果json字符串数据有效，将json字符串转换为java对象返回
            //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
            System.out.println("=============去redis查数据了=============================");
            JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Module.class);
            moduleList = objectMapper.readValue(jsonData,javaType);
        }
        //关闭连接
        jedis.close();

        return moduleList;
    }

    @Override
    public Module findById(String moduleId) throws Exception {
/*        Module module = null;
        ObjectMapper objectMapper = new ObjectMapper();
        //1.查询redis里面存储的类别列表数据返回json字符串数据
        //获取Jedis连接对象
        Jedis jedis = JedisUtils.getJedis();
        //读取缓存数据
        String jsonData = jedis.get("module"+moduleId);

        //2.判断字符串是否有数据
        if (jsonData==null){
            //3.如果json字符串数据无效，调用数据库获取，并写入缓存
            //调用dao获取类别列表数据
            module = moduleDao.findById(moduleId);
            //写入缓存
            jsonData = objectMapper.writeValueAsString(module);
            jedis.set("module"+moduleId,jsonData);
        }else{
            //4.如果json字符串数据有效，将json字符串转换为java对象返回
            //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
            module = objectMapper.readValue(jsonData,Module.class);
        }
        //关闭连接
        jedis.close();*/
        return moduleDao.findById(moduleId);
    }

    @Override
    public void save(Module module) throws JsonProcessingException {
    //    ObjectMapper objectMapper = new ObjectMapper();
        // 设置主键
        module.setId(UUID.randomUUID().toString());
        moduleDao.save(module);
     //   String id = module.getId();
        //redis的key加上id，以区分数据，用于获取或者删除
     //   String jsonData = objectMapper.writeValueAsString(module);
        Jedis jedis = JedisUtils.getJedis();
        jedis.flushDB();
   //     jedis.set("module"+id,jsonData);
        jedis.close();
    }

    @Override
    public void update(Module module) throws JsonProcessingException {
     //   ObjectMapper objectMapper = new ObjectMapper();
        moduleDao.update(module);
    //    String jsonData = objectMapper.writeValueAsString(module);
        Jedis jedis = JedisUtils.getJedis();
        //jedis.flushDB();
        jedis.del("moduleList");
       // jedis.set("module"+module.getId(),jsonData);

        jedis.close();
    }

    @Override
    public void delete(String id) {
        moduleDao.delete(id);
        Jedis jedis = JedisUtils.getJedis();
        jedis.flushDB();
        jedis.close();
    }

    @Override
    public List<Module> findModuleByRoleId(String roleId) throws Exception {
        List<Module> moduleList = null;
        ObjectMapper objectMapper = new ObjectMapper();
        //1.查询redis里面存储的类别列表数据返回json字符串数据
        //获取Jedis连接对象
        Jedis jedis = JedisUtils.getJedis();
        //读取缓存数据
        String jsonData = jedis.get("moduleListByRoleId"+roleId);

        //2.判断字符串是否有数据
        if (jsonData==null){
            //3.如果json字符串数据无效，调用数据库获取，并写入缓存
            //调用dao获取类别列表数据
            moduleList = moduleDao.findModuleByRoleId(roleId);
            System.out.println("=============去数据库查数据了=============================");
            //写入缓存
            jsonData = objectMapper.writeValueAsString(moduleList);
            jedis.set("moduleListByRoleId"+roleId,jsonData);
        }else{
            //4.如果json字符串数据有效，将json字符串转换为java对象返回
            //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
            System.out.println("=============去redis查数据了=============================");
            JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Module.class);
            moduleList = objectMapper.readValue(jsonData,javaType);
        }
        //关闭连接
        jedis.close();
        return moduleDao.findModuleByRoleId(roleId);
    }

    @Override
    public List<Module> findModuleByUserId(String userId) throws Exception {
        // 1. 根据用户id查询，获取登陆用户的degree等级
        User user = userDao.findById(userId);

        // 2. 获取用户等级
        Integer degree = user.getDegree();
        Subject subject = SecurityUtils.getSubject();

        // 3. 判断
        if (degree == 0) {
            //如果登陆用户degree=0，说明是saas管理员，只显示saas模块
            //SELECT * FROM ss_module WHERE belong=0
            List<Module> moduleList = null;
            ObjectMapper objectMapper = new ObjectMapper();
            //1.查询redis里面存储的类别列表数据返回json字符串数据
            //获取Jedis连接对象
            Jedis jedis = JedisUtils.getJedis();
            //读取缓存数据
            String jsonData = jedis.get("moduleListByBelong0");

            //2.判断字符串是否有数据
            if (jsonData==null){
                //3.如果json字符串数据无效，调用数据库获取，并写入缓存
                //调用dao获取类别列表数据
                moduleList = moduleDao.findByBelong(0);
                //写入缓存
                jsonData = objectMapper.writeValueAsString(moduleList);
                jedis.set("moduleListByBelong0",jsonData);
            }else{
                //4.如果json字符串数据有效，将json字符串转换为java对象返回
                //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Module.class);
                moduleList = objectMapper.readValue(jsonData,javaType);
            }
            //关闭连接
            jedis.close();
            return moduleList;
        }
        else if (degree == 1){
            //如果登陆用户degree=1，说明是企业管理员，显示除了saas意外的其他模块
            List<Module> moduleList = null;
            ObjectMapper objectMapper = new ObjectMapper();
            //1.查询redis里面存储的类别列表数据返回json字符串数据
            //获取Jedis连接对象
            Jedis jedis = JedisUtils.getJedis();
            //读取缓存数据
            String jsonData = jedis.get("moduleListByBelong1");

            //2.判断字符串是否有数据
            if (jsonData==null){
                //3.如果json字符串数据无效，调用数据库获取，并写入缓存
                //调用dao获取类别列表数据
                moduleList = moduleDao.findByBelong(1);
                //写入缓存
                jsonData = objectMapper.writeValueAsString(moduleList);
                jedis.set("moduleListByBelong1",jsonData);
            }else{
                //4.如果json字符串数据有效，将json字符串转换为java对象返回
                //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Module.class);
                moduleList = objectMapper.readValue(jsonData,javaType);
            }
            //关闭连接
            jedis.close();
            return moduleList;
        }
        else {
            // 如果登陆用户degree其他，就根据用户查询权限
            List<Module> moduleList = null;
            ObjectMapper objectMapper = new ObjectMapper();
            //1.查询redis里面存储的类别列表数据返回json字符串数据
            //获取Jedis连接对象
            Jedis jedis = JedisUtils.getJedis();
            //读取缓存数据
            String jsonData = jedis.get("moduleListByUserId"+userId);

            //2.判断字符串是否有数据
            if (jsonData==null){
                //3.如果json字符串数据无效，调用数据库获取，并写入缓存
                //调用dao获取类别列表数据
                moduleList = moduleDao.findModuleByUserId(userId);
                //写入缓存
                jsonData = objectMapper.writeValueAsString(moduleList);
                jedis.set("moduleListByUserId"+userId,jsonData);
            }else{
                //4.如果json字符串数据有效，将json字符串转换为java对象返回
                //json字符串转换为java对象语法：objectMapper.readValue(json字符串,java类
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Module.class);
                moduleList = objectMapper.readValue(jsonData,javaType);
            }
            //关闭连接
            jedis.close();
            return moduleList;
        }
    }
}
